// // // // // #include <QCoreApplication>
// // // // // #include <iostream>
// // // // // #include <thread>
// // // // // using namespace std;

// // // // // void thfunc(int n)  //线程函数
// // // // // {
// // // // //     cout << "thfunc: " << n <<endl;   //这里的n是1
// // // // // }

// // // // // int main(int argc, char *argv[])
// // // // // {
// // // // //     QCoreApplication a(argc, argv);
// // // // //     thread t(thfunc,1);  //定义线程对象t，并把线程函数指针和线程函数参数传入
// // // // //     t.join();  //等待线程对象t结束
// // // // //     return a.exec();
// // // // // }


// // // // #include <QCoreApplication>
// // // // #include <iostream>
// // // // #include <thread>
// // // // using namespace std;

// // // // typedef struct  //定义结构体的类型
// // // // {
// // // //     int n;
// // // //     const char *str; //注意这里要有const，否则会有警告
// // // // }MYSTRUCT;

// // // // void thfunc(void *arg)  //线程函数
// // // // {
// // // //     MYSTRUCT *p = (MYSTRUCT*)arg;
// // // //     cout << "in thfunc:n=" << p->n<<",str="<< p->str <<endl; //打印结构体的内容
// // // // }

// // // // int main(int argc, char *argv[])
// // // // {
// // // //     QCoreApplication a(argc, argv);
// // // //     MYSTRUCT mystruct; //定义结构体
// // // //     //初始化结构体
// // // //     mystruct.n = 110;
// // // //     mystruct.str = "hello world";

// // // //     thread t(thfunc, &mystruct);  //定义线程对象t，并把结构体变量的地址传入
// // // //     t.join();  //等待线程对象t结束

// // // //     return a.exec();
// // // // }


// // // #include <QCoreApplication>
// // // #include <iostream>
// // // #include <thread>
// // // using namespace std;

// // // void thfunc(int n,int m,int *pk,char s[])  //线程函数
// // // {
// // //     cout << "in thfunc:n=" <<n<<",m="<<m<<",k="<<* pk <<"\nstr="<<s<<endl;
// // //     *pk = 5000;  //修改* pk
// // // }

// // // int main(int argc, char *argv[])
// // // {
// // //     QCoreApplication a(argc, argv);
// // //     int n = 110,m=200,k=5;
// // //     char str[] = "hello world";

// // //     thread t(thfunc, n,m,&k,str);  //定义线程对象t，并传入多个参数
// // //     t.join();  //等待线程对象t结束
// // //     cout << "k=" << k << endl;  //此时打印应该是5000

// // //     return a.exec();
// // // }
// // #include <QCoreApplication>
// // #include <iostream>
// // #include <thread>
// // #include <unistd.h> //for sleep
// // using namespace std;
// // void thfunc(int n,int m,int *k,char s[])  //线程函数
// // {
// //     cout << "in thfunc:n=" <<n<<",m="<<m<<",k="<<*k<<"\nstr="<<s<<endl;
// //     *k = 5000;
// // }

// // int main(int argc, char *argv[])
// // {
// //     QCoreApplication a(argc, argv);
// //     int n = 110,m=200,k=5;
// //     char str[] = "hello world";

// //     thread t(thfunc, n,m,&k,str);   //定义线程对象
// //     sleep(1);
// //     t.detach();  //分离线程

// //     cout << "k=" << k << endl;  //这里输出3
// //     pthread_exit(NULL); //main线程结束，但进程并不会结束，下面一句不会执行

// //     cout << "this line will not run"<< endl;  //这一句不会执行

// //     return a.exec();
// // }




// #include <QCoreApplication>

// #include <iostream>       // std::cout
// #include <thread>         // std::thread, std::this_thread::yield
// #include <atomic>         // std::atomic
// using namespace std;

// atomic<bool> ready(false); //定义全局变量

// void thfunc(int id)
// {
//     while (!ready) //一直等待，知道main线程中重置全局变量ready
//         this_thread::yield(); //让出自己的CPU时间片

//     for (volatile int i = 0; i < 1000000; ++i) //开始累加到1百万
//     {}
//     cout << id<<",";//累加完毕后，打印本线程的序号，这样最终输出的是排名，先完成先打印
// }


// int main(int argc, char *argv[])
// {
//     QCoreApplication a(argc, argv);
//     thread threads[10]; //定义10个线程对象
//     cout << "race of 10 threads that count to 1 million:\n";
//     for (int i = 0; i < 10; ++i)
//         threads[i] = thread(thfunc, i); //启动线程，把i当作参数传入线程函数，用于标记线程的序号
//     ready = true;               // 重置全局变量
//     for (auto& th : threads) th.join(); //等待10个线程全部结束
//     cout << endl;

//     return a.exec();
// }
// #include <QCoreApplication>
// #include <QThread>
// #include <iostream>
// using namespace std;
// class MyThread : public QThread
// {
// public:
//     virtual void run();
// };

// void MyThread::run()
// {
//     for( int count = 0; count < 10; count++ ) {
//         qDebug( "ping %d",count );
//     }
// }

// int main(int argc, char *argv[])
// {
//     QCoreApplication a(argc, argv);
//     MyThread thA;

//     thA.start();//自动调用run(),否则即使该线程创建，也是一开始就挂起
//     //要等待线程a退出
//     thA.wait();
//     cout<<"thread A is over.";
//     cout<<endl;
//     return a.exec();
// }


/*

#include <QCoreApplication>
#include <QThread>
#include <QDebug>
#include <QMutex>

#include <QElapsedTimer>
#pragma execution_character_set("utf-8")//Qt5 显示
// 定义共享资源
int sharedValue = 0;
QMutex mutex;

// 定义一个线程类
class MyThread : public QThread
{

public:
    void run() override {
        for(int i = 0; i < 5; i++) {
            QMutexLocker locker(&mutex); // 创建 QMutexLocker 对象并传递 QMutex 对象
            sharedValue++; // 访问共享资源
            qDebug() << "Thread ID: " << QThread::currentThreadId() << " - Shared Value: " << sharedValue;
          //  msleep(1000); // 线程休眠1秒
        }
    }
    // void run() override {
    //     for(int i = 0; i < 5; i++) {
    //         mutex.lock(); // 加锁
    //         sharedValue++; // 访问共享资源
    //         qDebug() << "Thread ID: " << QThread::currentThreadId() << " - Shared Value: " << sharedValue;
    //         msleep(1000); // 线程休眠1秒
    //         mutex.unlock(); // 解锁
    //     }
    // }
};

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    MyThread thread1;
    // MyThread thread2;
    // MyThread thread3;
    // MyThread thread4;

    //计算程序运行时间方法
    QElapsedTimer timer;
    timer.start();
    thread1.start();
    // thread2.start();
    // thread3.start();
    // thread4.start();

    thread1.wait();
    // thread2.wait();
    // thread3.wait();
    // thread4.wait();

    qDebug() << "Final Shared Value: " << sharedValue;
    qDebug() << "The slow operation took" << timer.elapsed() << "milliseconds";
    //2 The slow operation took 5 milliseconds
    //4 The slow operation took 6 milliseconds
    //1 The slow operation took 4 milliseconds
    return a.exec();
}



*/
#include <QCoreApplication>
#include <QThread>
#include <QDebug>
#include <QWaitCondition>
#include <QMutex>
#include <QQueue>

QMutex mutex;  // 创建一个互斥锁，确保线程安全
QWaitCondition queueNotEmpty; // 创建一个条件变量，表示队列非空
QQueue<int> queue; // 创建一个队列用于存储数据

// 生产者线程
class ProducerThread : public QThread
{
public:
    void run() override
    {
        int i=0;
        while(1){
            i++;
            // 生产数据并加入队列
            {
                QMutexLocker locker(&mutex); // 加锁
                queue.enqueue(i); // 生产数据并加入队列
                qDebug() << "Produced: " << i;
                qDebug()<<"";
                queueNotEmpty.wakeOne();  // 通知消费者队列非空
            }
            msleep(3000);  // 休眠一段时间
        }
    }
};

// 消费者线程
class ConsumerThread : public QThread
{
public:
    void run() override
    {
        while(1){
            // 检查队列是否为空，如果为空则等待
            {
                QMutexLocker locker(&mutex); // 加锁
                while (queue.isEmpty()) {
                    queueNotEmpty.wait(&mutex); // 等待条件变量，直到队列非空
                }
                int value = queue.dequeue();  // 从队列中取出数据
                qDebug() << "Consumed: " << value;
            }
            msleep(3000);  // 休眠一段时间
        }
    }
};

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    // 创建生产者线程和消费者线程
    ProducerThread producer;
    ConsumerThread consumer;

    // 启动线程
    producer.start();
    consumer.start();

    // 等待线程结束
    producer.wait();
    consumer.wait();

    return a.exec();
}
